/**
 * nx-request
 * @description api模块管理，loading配置，请求拦截，错误处理
 */

import Request from 'luch-request';
import {
  baseUrl,
  apiPath
} from '@/nx/config';
import $store from '@/nx/store';
import getStorageItem from '@/utils/getStorageItem';

const options = {
  // 显示操作成功消息 默认不显示
  showSuccess: false,
  // 成功提醒 默认使用后端返回值
  successMsg: '',
  // 显示失败消息 默认显示
  showError: true,
  // 失败提醒 默认使用后端返回信息
  errorMsg: '',
  // 显示请求时loading模态框 默认显示
  showLoading: true,
  // loading提醒文字
  loadingMsg: '加载中',
  // 需要授权才能请求 默认放开
  auth: false,
  // ...
  // 是否需要用refreshToken
  rToken: false,
};

// Loading全局实例
let LoadingInstance = {
  target: null,
  count: 0,
};

/**
 * 关闭loading
 */
function closeLoading() {
  // console.log("调用close方法时",LoadingInstance.count);
  if (LoadingInstance.count > 0) {
    // console.log("调用close方法[--]",LoadingInstance.count);
    LoadingInstance.count--;
    // console.log("调用close方法[--]后",LoadingInstance.count);
  }
  if (LoadingInstance.count === 0) {
    // console.log("调用close方法[关闭]",LoadingInstance.count);
    uni.hideLoading();
  }
}

/**
 * @description 请求基础配置 可直接使用访问自定义请求
 */
const http = new Request({
  baseURL: baseUrl,
  timeout: 8000,
  method: 'GET',
  header: {
    Accept: 'text/json',
    'Content-Type': 'application/json;charset=UTF-8',
  },
  // #ifdef APP-PLUS
  sslVerify: false,
  // #endif
  // #ifdef H5
  // 跨域请求时是否携带凭证（cookies）仅H5支持（HBuilderX 2.6.15+）
  withCredentials: false,
  // #endif
  custom: options,
});

/**
 * @description 请求拦截器
 */
http.interceptors.request.use(
  (config) => {
    // if (config.custom.auth && !$store('user').isLogin) {
    //   // 这里做未登录拦截
    //   return Promise.reject();
    // }
    if (config.custom.showLoading) {
      LoadingInstance.count++;
      LoadingInstance.count === 1 &&
        uni.showLoading({
          title: config.custom.loadingMsg,
          mask: true,
          fail: () => {
            uni.hideLoading();
          },
        });
    }
    const token = uni.getStorageSync("token")
    if (token) {
      // console.log("token设置", token.accessToken);
      config.header['Authorization'] = 'Bearer ' + token.accessToken;
      if (config.custom.rToken) {
        // console.log("设置为refreshToken");
        config.header['Authorization'] = 'Bearer ' + token.refreshToken;
      }
    }
    // storage中可能根本没有该字段
    //   const {
    //     token
    //   } = user
    //   if (token.accessToken) {
    //     // 只有accessToken有的时候才设置
    //     console.log("token设置", token);
    //     config.header['Authorization'] = 'Bearer ' + token.accessToken;
    //   }
    //   // 如果要用refreshToken
    //   if (config.custom.rToken && token.refreshToken){
    //     console.log("设置为refreshToken");
    //     config.header['Authorization'] = 'Bearer ' + token.refreshToken;
    //   }
    // }


    // console.log('请求config', config);
    return config;
  },
  (error) => {
    return Promise.reject(error);
  },
);

// 对jwt过期调试无痛刷新
// 设置一个标志，是否在刷新
let isRefreshing = false
// 刷新中其他等待的请求
let pending = []
/**
 * @description 响应拦截器
 */
http.interceptors.response.use(
  (response) => {
    // console.log("【request成功返回】", response)
    // 自动设置登陆令牌
    if (response.header.authorization || response.header.Authorization) {
      // console.log('response中调用setToken');
      $store('user').setToken(response.header.authorization || response.header.Authorization);
    }

    response.config.custom.showLoading && closeLoading();
    if (response.data.code !== 200) {
      // 成功返回，但不是200，后续具体再看
      if (response.config.custom.showError) {
        // console.log('一开始登录页面进入了@@@');
        uni.showToast({
          title: response.data.msg || '服务器开小差啦,请稍后再试~',
          // title: '服务器开小差啦,请稍后再试~',
          icon: 'none',
          mask: true,
        });
        return Promise.resolve(response.data);
      }
    } else {
      // 返回值是200的情况，即正常访问
      if (
        // 如果有需要显示成功信息
        // response.data.error === 0 &&
        // response.data.msg !== '' &&
        response.config.custom.showSuccess
      ) {
        // console.log('一开始登录页面进入了###');
        uni.showToast({
          // 成功的默认信息或者返回数据中的信息
          title: response.config.custom.successMsg || response.data.msg,
          icon: 'none',
        });
      }
      // 如果没有需求，就直接返回res
      return Promise.resolve(response.data);
    }
  },
  async (error) => {
    const userStore = $store('user');
    // const isLogin = userStore.isLogin;
    let errorMessage = '网络请求出错';
    console.log("【response中】", error);
    if (error !== undefined) {
      switch (error.statusCode) {
        case 400:
          errorMessage = '请求错误';
          break;
          // 两种情况都先尝试refresh
        case 401:
          errorMessage = '401错误'
          // 对有重新刷新token的关闭加载框
          error.config.custom.showLoading && closeLoading();
          if (!isRefreshing) {
            isRefreshing = true
            let resp = await userStore.refreshToken()
            // console.log("401错误触发",LoadingInstance)
            if (resp === '刷新成功') {
              // 刷新完TOKEN
              // console.log('剩余需要的请求pending', pending);
              pending.forEach((item) => {
                // console.log(item);
                request(item)
              })
              // 清空pending
              pending = []
              // console.log('测试测试',resp)
              // console.log('测试测试config',error.config)
              isRefreshing = false
              return request(error.config)
            } else {
              uni.reLaunch({
                url:'/pages/login/login'
              })
            }
          } else {
            // 正在刷新token
            // console.log("刷新中",error.config);
            return pending.push(error.config)
            // return new Promise(resolve =>{
            //   pending.push(()=>resolve(error.config))
            // console.log('正在刷新token', pending);
            // })
          }
          break
        case 402:
          break
          //   if (isLogin) {
          //     errorMessage = '您的登陆已过期';
          //   } else {
          //     errorMessage = '请先登录';
          //   }
          //   userStore.logout(true);
          //   break;
        case 403:
          errorMessage = '拒绝访问';
          userStore.logout() // 直接退回到首页
          break;
        case 404:
          errorMessage = '请求出错';
          break;
        case 406:
          errorMessage = '请求出错';
          break;
        case 408:
          errorMessage = '请求超时';
          break;
        case 429:
          errorMessage = '请求频繁, 请稍后再访问';
          break;
        case 500:
          errorMessage = '服务器开小差啦,请稍后再试~';
          break;
        case 501:
          errorMessage = '服务未实现';
          break;
        case 502:
          errorMessage = '网络错误';
          break;
        case 503:
          errorMessage = '服务不可用';
          break;
        case 504:
          errorMessage = '网络超时';
          break;
        case 505:
          errorMessage = 'HTTP版本不受支持';
          break;
      }
      if (error.errMsg.includes('timeout')) errorMessage = '请求超时';
      // #ifdef H5
      if (error.errMsg.includes('Network'))
        errorMessage = window.navigator.onLine ? '服务器异常' : '请检查您的网络连接';
      // #endif
    }

    if (error && error.config) {
      console.log('刷新后进入么？', error.config);
      // uni.reLaunch({
      //   url: '/pages/login/login'
      // })
      if (error.config.custom.showError === true) {
        console.log('请求错误，返回登录页');
        uni.showToast({
          title: error.data?.msg || errorMessage,
          icon: 'none',
          mask: true,
        });
      }
      error.config.custom.showLoading && closeLoading();
    }

    // return false;
    return error.data
  },
);

const request = (config) => {
  if (config.url[0] !== '/') {
    // 就是可以省略开头的一种写法：如果不以 / 开头，请求地址就加入apiPath
    config.url = apiPath + config.url;
  }
  return http.middleware(config);
};

export default request;